const express = require('express');
const jwt = require('jsonwebtoken');
const { User, UserProfile } = require('../models');
const { authenticateToken } = require('../middleware/auth');
const { validateUserRegistration, validateUserLogin } = require('../middleware/validation');
const { Op } = require('sequelize');

const router = express.Router();

// 用户注册
router.post('/register', validateUserRegistration, async (req, res) => {
  try {
    const { username, email, password } = req.body;

    // 检查用户是否已存在
    const existingUser = await User.findOne({
      where: {
        [Op.or]: [{ email }, { username }]
      }
    });

    if (existingUser) {
      return res.status(400).json({
        error: '用户名或邮箱已存在'
      });
    }

    // 创建用户
    const user = await User.create({
      username,
      email,
      password_hash: password // 会在模型的hook中自动加密
    });

    // 创建用户画像
    await UserProfile.create({
      user_id: user.id,
      interests: [],
      activity_preferences: {}
    });

    // 生成JWT令牌
    const token = jwt.sign(
      { userId: user.id, username: user.username },
      process.env.JWT_SECRET,
      { expiresIn: process.env.JWT_EXPIRES_IN || '7d' }
    );

    res.status(201).json({
      message: '注册成功',
      user: user.getPublicInfo(),
      token
    });
  } catch (error) {
    console.error('注册失败:', error);
    res.status(500).json({
      error: '注册失败',
      details: error.message
    });
  }
});

// 用户登录
router.post('/login', validateUserLogin, async (req, res) => {
  try {
    const { email, password } = req.body;

    // 查找用户
    const user = await User.findOne({ where: { email } });
    if (!user) {
      return res.status(401).json({
        error: '邮箱或密码错误'
      });
    }

    // 验证密码
    const isValidPassword = await user.validatePassword(password);
    if (!isValidPassword) {
      return res.status(401).json({
        error: '邮箱或密码错误'
      });
    }

    // 检查用户是否被禁用
    if (!user.is_active) {
      return res.status(401).json({
        error: '账户已被禁用'
      });
    }

    // 更新最后登录时间
    await user.update({ last_login: new Date() });

    // 生成JWT令牌
    const token = jwt.sign(
      { userId: user.id, username: user.username },
      process.env.JWT_SECRET,
      { expiresIn: process.env.JWT_EXPIRES_IN || '7d' }
    );

    res.json({
      message: '登录成功',
      user: user.getPublicInfo(),
      token
    });
  } catch (error) {
    console.error('登录失败:', error);
    res.status(500).json({
      error: '登录失败',
      details: error.message
    });
  }
});

// 获取当前用户信息
router.get('/me', authenticateToken, async (req, res) => {
  try {
    const user = await User.findByPk(req.user.id, {
      include: [
        {
          model: UserProfile,
          as: 'profile'
        }
      ]
    });

    if (!user) {
      return res.status(404).json({
        error: '用户不存在'
      });
    }

    res.json({
      user: user.getPublicInfo(),
      profile: user.profile
    });
  } catch (error) {
    console.error('获取用户信息失败:', error);
    res.status(500).json({
      error: '获取用户信息失败'
    });
  }
});

// 更新用户信息
router.put('/me', authenticateToken, async (req, res) => {
  try {
    const { username, bio, avatar_url } = req.body;
    const user = await User.findByPk(req.user.id);

    if (!user) {
      return res.status(404).json({
        error: '用户不存在'
      });
    }

    // 检查用户名是否已被使用
    if (username && username !== user.username) {
      const existingUser = await User.findOne({ where: { username } });
      if (existingUser) {
        return res.status(400).json({
          error: '用户名已被使用'
        });
      }
    }

    await user.update({
      username: username || user.username,
      bio: bio !== undefined ? bio : user.bio,
      avatar_url: avatar_url !== undefined ? avatar_url : user.avatar_url
    });

    res.json({
      message: '用户信息更新成功',
      user: user.getPublicInfo()
    });
  } catch (error) {
    console.error('更新用户信息失败:', error);
    res.status(500).json({
      error: '更新用户信息失败'
    });
  }
});

// 修改密码
router.put('/password', authenticateToken, async (req, res) => {
  try {
    const { currentPassword, newPassword } = req.body;

    if (!currentPassword || !newPassword) {
      return res.status(400).json({
        error: '当前密码和新密码不能为空'
      });
    }

    const user = await User.findByPk(req.user.id);
    if (!user) {
      return res.status(404).json({
        error: '用户不存在'
      });
    }

    // 验证当前密码
    const isValidPassword = await user.validatePassword(currentPassword);
    if (!isValidPassword) {
      return res.status(401).json({
        error: '当前密码错误'
      });
    }

    // 更新密码
    await user.update({ password_hash: newPassword });

    res.json({
      message: '密码修改成功'
    });
  } catch (error) {
    console.error('修改密码失败:', error);
    res.status(500).json({
      error: '修改密码失败'
    });
  }
});

// 刷新令牌
router.post('/refresh', authenticateToken, async (req, res) => {
  try {
    const user = await User.findByPk(req.user.id);
    if (!user || !user.is_active) {
      return res.status(401).json({
        error: '用户不存在或已被禁用'
      });
    }

    // 生成新的JWT令牌
    const token = jwt.sign(
      { userId: user.id, username: user.username },
      process.env.JWT_SECRET,
      { expiresIn: process.env.JWT_EXPIRES_IN || '7d' }
    );

    res.json({
      message: '令牌刷新成功',
      token
    });
  } catch (error) {
    console.error('刷新令牌失败:', error);
    res.status(500).json({
      error: '刷新令牌失败'
    });
  }
});

module.exports = router; 